import 'dart:async';
import 'package:flutter/services.dart';
import 'sms_message.dart';
import 'sms_permissions.dart';
import 'sms_sender.dart';

/// 短信监听回调函数类型定义
typedef SmsReceivedCallback = void Function(SmsMessage message);

/// 短信监听器主类
///
/// 提供完整的短信监听和发送功能，包括权限管理、监听控制、消息回调和发送功能
/// 支持基于前台服务的真正后台监听和两种发送模式（后台发送和系统界面发送）
class SmsListener {
  /// Method Channel用于与Android原生代码通信
  static const MethodChannel _channel = MethodChannel('sms_listener');

  /// Event Channel用于接收短信事件
  static const EventChannel _eventChannel = EventChannel('sms_listener/events');

  /// 事件流订阅
  StreamSubscription<dynamic>? _eventSubscription;

  /// 短信接收回调函数
  SmsReceivedCallback? _onSmsReceived;

  /// 是否正在监听状态
  bool _isListening = false;

  /// 错误回调函数
  Function(String error)? _onError;

  /// 短信发送器实例
  late final SmsSender _smsSender;

  /// 构造函数
  SmsListener() {
    _smsSender = SmsSender();
  }

  /// 获取当前监听状态
  bool get isListening => _isListening;

  /// 获取短信发送器实例
  SmsSender get sender => _smsSender;

  /// 请求SMS相关权限（仅接收权限）
  ///
  /// 返回值：
  /// - true: 权限获取成功
  /// - false: 权限获取失败
  Future<bool> requestPermissions() async {
    try {
      return await SmsPermissions.requestSmsPermissions();
    } catch (e) {
      _handleError('请求权限时发生错误: $e');
      return false;
    }
  }

  /// 请求SMS发送权限
  ///
  /// 返回值：
  /// - true: 发送权限获取成功
  /// - false: 发送权限获取失败
  Future<bool> requestSendPermission() async {
    try {
      return await SmsPermissions.requestSmsSendPermission();
    } catch (e) {
      _handleError('请求发送权限时发生错误: $e');
      return false;
    }
  }

  /// 请求所有SMS权限（接收和发送）
  ///
  /// 返回值：
  /// - true: 所有权限获取成功
  /// - false: 部分或全部权限获取失败
  Future<bool> requestAllPermissions() async {
    try {
      return await SmsPermissions.requestAllSmsPermissions();
    } catch (e) {
      _handleError('请求所有权限时发生错误: $e');
      return false;
    }
  }

  /// 检查是否已有SMS权限
  ///
  /// 返回值：
  /// - true: 已有所需权限
  /// - false: 缺少权限
  Future<bool> hasPermissions() async {
    try {
      return await SmsPermissions.hasSmsPermissions();
    } catch (e) {
      _handleError('检查权限时发生错误: $e');
      return false;
    }
  }

  /// 检查是否已有SMS发送权限
  ///
  /// 返回值：
  /// - true: 已有发送权限
  /// - false: 缺少发送权限
  Future<bool> hasSendPermission() async {
    try {
      return await SmsPermissions.hasSmsSendPermission();
    } catch (e) {
      _handleError('检查发送权限时发生错误: $e');
      return false;
    }
  }

  /// 检查是否已有所有SMS权限（接收和发送）
  ///
  /// 返回值：
  /// - true: 已有所有权限
  /// - false: 缺少部分或全部权限
  Future<bool> hasAllPermissions() async {
    try {
      return await SmsPermissions.hasAllSmsPermissions();
    } catch (e) {
      _handleError('检查所有权限时发生错误: $e');
      return false;
    }
  }

  /// 开始监听短信
  ///
  /// [onSmsReceived] 收到短信时的回调函数
  /// [onError] 发生错误时的回调函数（可选）
  /// [enableBackground] 是否启用后台监听（默认true）
  /// [filterSenders] 发送者过滤列表（可选）
  ///
  /// 在开始监听前会自动检查权限
  Future<void> startListening(
    SmsReceivedCallback onSmsReceived, {
    Function(String error)? onError,
    bool enableBackground = true,
    List<String>? filterSenders,
  }) async {
    if (_isListening) {
      _handleError('短信监听器已经在运行中');
      return;
    }

    _onSmsReceived = onSmsReceived;
    _onError = onError;

    // 检查权限
    final bool hasPermission = await hasPermissions();
    if (!hasPermission) {
      _handleError('缺少必要的SMS权限，无法开始监听');
      return;
    }

    try {
      // 配置监听器
      await configure(
        enableBackground: enableBackground,
        filterSenders: filterSenders,
      );

      // 调用原生方法开始监听
      final bool result = await _channel.invokeMethod('startListening');

      if (result) {
        // 订阅事件流
        print('开始订阅短信事件流...');
        _eventSubscription = _eventChannel.receiveBroadcastStream().listen(
              _handleSmsEvent,
              onError: _handleEventError,
              onDone: _handleEventDone,
            );

        _isListening = true;
        print('短信监听已开始 - 后台监听: $enableBackground');
        print('事件流订阅成功，等待短信事件...');
      } else {
        _handleError('启动短信监听失败');
      }
    } catch (e) {
      _handleError('启动短信监听时发生错误: $e');
    }
  }

  /// 停止监听短信
  ///
  /// 停止监听后将自动停止前台服务
  Future<void> stopListening() async {
    if (!_isListening) {
      return;
    }

    try {
      // 取消事件流订阅
      await _eventSubscription?.cancel();
      _eventSubscription = null;

      // 调用原生方法停止监听
      await _channel.invokeMethod('stopListening');

      _isListening = false;
      _onSmsReceived = null;
      _onError = null;

      print('短信监听已停止');
    } catch (e) {
      _handleError('停止短信监听时发生错误: $e');
    }
  }

  /// 配置监听器
  ///
  /// [enableBackground] 是否启用后台监听
  /// [filterSenders] 发送者过滤列表
  Future<void> configure({
    bool enableBackground = true,
    List<String>? filterSenders,
  }) async {
    try {
      await _channel.invokeMethod('configure', {
        'enableBackground': enableBackground,
        'filterSender': filterSenders,
      });
    } catch (e) {
      _handleError('配置监听器时发生错误: $e');
    }
  }

  /// 获取最新的短信
  ///
  /// 返回值：SmsMessage对象或null
  Future<SmsMessage?> getLastSms() async {
    try {
      final dynamic result = await _channel.invokeMethod('getLastSms');
      if (result != null) {
        return SmsMessage.fromMap(Map<String, dynamic>.from(result));
      }
      return null;
    } catch (e) {
      _handleError('获取最新短信时发生错误: $e');
      return null;
    }
  }

  /// 获取短信历史记录
  ///
  /// [limit] 获取数量限制（默认10条）
  /// [offset] 偏移量（默认0）
  ///
  /// 返回值：SmsMessage列表
  Future<List<SmsMessage>> getSmsHistory({
    int limit = 10,
    int offset = 0,
  }) async {
    try {
      final dynamic result = await _channel.invokeMethod('getSmsHistory', {
        'limit': limit,
        'offset': offset,
      });

      if (result is List) {
        return result
            .map((item) => SmsMessage.fromMap(Map<String, dynamic>.from(item)))
            .toList();
      }
      return [];
    } catch (e) {
      _handleError('获取短信历史时发生错误: $e');
      return [];
    }
  }

  /// 处理短信事件
  void _handleSmsEvent(dynamic event) {
    print('Flutter端收到事件: $event');
    try {
      // 确保数据是Map类型，然后转换为Map<String, dynamic>
      if (event is Map) {
        print('事件数据是Map类型，开始转换');
        final Map<String, dynamic> eventMap = Map<String, dynamic>.from(event);
        print('Map转换成功，开始解析SMS消息');
        final message = SmsMessage.fromMap(eventMap);
        print('SMS消息解析成功: 发送者=${message.address}, 内容=${message.body}');
        _onSmsReceived?.call(message);
      } else {
        print('事件数据类型错误: ${event.runtimeType}，期望Map类型');
      }
    } catch (e) {
      print('处理短信事件时发生错误: $e');
      _handleError('处理短信事件时发生错误: $e');
    }
  }

  /// 处理事件流错误
  void _handleEventError(dynamic error) {
    print('短信事件流错误: $error');
    _handleError('短信事件流错误: $error');
  }

  /// 处理事件流完成
  void _handleEventDone() {
    print('短信事件流已关闭');
  }

  /// 处理错误
  void _handleError(String error) {
    print('SMS监听器错误: $error');
    _onError?.call(error);
  }

  /// 发送短信（后台模式）
  ///
  /// [phoneNumber] 接收者手机号码
  /// [message] 短信内容
  /// [requestPermissionIfNeeded] 是否在权限不足时自动请求权限（默认true）
  ///
  /// 返回值：SmsSendResult包含发送结果和详细信息
  Future<SmsSendResult> sendSmsBackground({
    required String phoneNumber,
    required String message,
    bool requestPermissionIfNeeded = true,
  }) async {
    return await _smsSender.sendSmsBackground(
      phoneNumber: phoneNumber,
      message: message,
      requestPermissionIfNeeded: requestPermissionIfNeeded,
    );
  }

  /// 发送短信（系统界面模式）
  ///
  /// [phoneNumber] 接收者手机号码（可选）
  /// [message] 短信内容（可选）
  ///
  /// 返回值：SmsSendResult包含操作结果
  Future<SmsSendResult> sendSmsWithSystemIntent({
    String? phoneNumber,
    String? message,
  }) async {
    return await _smsSender.sendSmsWithSystemIntent(
      phoneNumber: phoneNumber,
      message: message,
    );
  }

  /// 发送短信（智能模式）
  ///
  /// 优先使用后台模式，权限不足时自动回退到系统界面模式
  ///
  /// [phoneNumber] 接收者手机号码
  /// [message] 短信内容
  /// [requestPermissionIfNeeded] 是否在权限不足时自动请求权限（默认true）
  /// [fallbackToIntent] 权限获取失败时是否回退到系统界面模式（默认true）
  ///
  /// 返回值：SmsSendResult包含发送结果和实际使用的模式
  Future<SmsSendResult> sendSms({
    required String phoneNumber,
    required String message,
    bool requestPermissionIfNeeded = true,
    bool fallbackToIntent = true,
  }) async {
    return await _smsSender.sendSms(
      phoneNumber: phoneNumber,
      message: message,
      requestPermissionIfNeeded: requestPermissionIfNeeded,
      fallbackToIntent: fallbackToIntent,
    );
  }

  /// 检查是否可以使用后台发送模式
  ///
  /// 返回值：true表示有SEND_SMS权限，可以后台发送
  Future<bool> canSendBackground() async {
    return await _smsSender.canSendBackground();
  }

  /// 检查设备是否支持短信功能
  ///
  /// 返回值：true表示设备支持短信功能
  Future<bool> isSmsAvailable() async {
    return await _smsSender.isSmsAvailable();
  }

  /// 获取默认短信应用包名
  ///
  /// 返回值：默认短信应用的包名，如果获取失败返回null
  Future<String?> getDefaultSmsApp() async {
    return await _smsSender.getDefaultSmsApp();
  }

  /// 销毁监听器
  ///
  /// 释放所有资源
  Future<void> dispose() async {
    await stopListening();
  }
}
